/**
 * ECharts 工具函数
 * 用于处理ECharts图表的数据验证和错误处理
 */

// 全局错误处理 - 屏蔽 ECharts 错误
window.addEventListener('error', function(event) {
  // 检查是否是 ECharts 相关错误
  if (event.error && event.error.stack && event.error.stack.includes('echarts')) {
    console.warn('ECharts 错误已被屏蔽:', event.error.message)
    event.preventDefault()
    event.stopPropagation()
    return false
  }
})

// 屏蔽未捕获的 Promise 错误中的 ECharts 错误
window.addEventListener('unhandledrejection', function(event) {
  if (event.reason && event.reason.stack && event.reason.stack.includes('echarts')) {
    console.warn('ECharts Promise 错误已被屏蔽:', event.reason.message)
    event.preventDefault()
    return false
  }
})

/**
 * 验证数据是否为有效的数组
 * @param {any} data - 要验证的数据
 * @returns {boolean} 是否为有效数组
 */
export function isValidArray(data) {
  return Array.isArray(data) && data.length > 0
}

/**
 * 验证数据项是否包含必要字段
 * @param {Object} item - 数据项
 * @param {Array} requiredFields - 必需字段数组
 * @returns {boolean} 是否包含所有必需字段
 */
export function hasRequiredFields(item, requiredFields = []) {
  if (!item || typeof item !== 'object') return false
  return requiredFields.every(field => item.hasOwnProperty(field) && item[field] !== undefined)
}

/**
 * 清理和标准化数据
 * @param {Array} data - 原始数据
 * @param {Object} fieldMapping - 字段映射配置
 * @returns {Array} 清理后的数据
 */
export function cleanChartData(data, fieldMapping = {}) {
  if (!isValidArray(data)) return []
  
  return data
    .filter(item => item && typeof item === 'object')
    .map(item => {
      const cleanedItem = {}
      Object.keys(fieldMapping).forEach(key => {
        const mappedKey = fieldMapping[key]
        cleanedItem[key] = item[mappedKey] || 0
      })
      return cleanedItem
    })
    .filter(item => Object.values(item).some(value => value > 0)) // 过滤掉所有值都为0的项
}

/**
 * 创建空数据配置
 * @param {string} title - 图表标题
 * @param {string} chartType - 图表类型
 * @returns {Object} 空数据配置
 */
export function createEmptyChartOption(title, chartType = 'bar') {
  const baseOption = {
    title: {
      text: title,
      left: 'center',
      textStyle: {
        fontSize: 16,
        fontWeight: 'bold'
      }
    }
  }

  if (chartType === 'pie') {
    return {
      ...baseOption,
      series: [{
        name: '数据',
        type: 'pie',
        radius: ['40%', '70%'],
        center: ['50%', '50%'],
        data: [{ value: 0, name: '暂无数据' }]
      }]
    }
  }

  if (chartType === 'line') {
    return {
      ...baseOption,
      xAxis: {
        type: 'category',
        data: ['暂无数据']
      },
      yAxis: {
        type: 'value'
      },
      series: [{
        name: '数据',
        type: 'line',
        data: [0]
      }]
    }
  }

  // 默认柱状图
  return {
    ...baseOption,
    xAxis: {
      type: 'category',
      data: ['暂无数据']
    },
    yAxis: {
      type: 'value'
    },
    series: [{
      name: '数据',
      type: 'bar',
      data: [0]
    }]
  }
}

/**
 * 安全地设置图表选项
 * @param {Object} chartInstance - ECharts实例
 * @param {Object} option - 图表配置
 * @param {boolean} notMerge - 是否不合并配置
 */
export function safeSetOption(chartInstance, option, notMerge = false) {
  if (!chartInstance) {
    console.warn('图表实例不存在，无法设置选项')
    return
  }
  
  // 验证图表实例是否有效
  if (!chartInstance.setOption || typeof chartInstance.setOption !== 'function') {
    console.warn('图表实例无效，跳过设置选项')
    return
  }
  
  // 验证选项是否有效
  if (!option || typeof option !== 'object') {
    console.warn('图表选项无效，使用默认配置')
    option = createEmptyChartOption('数据加载失败', 'bar')
  }
  
  try {
    // 添加防抖处理，避免频繁调用
    if (chartInstance._setOptionTimer) {
      clearTimeout(chartInstance._setOptionTimer)
    }
    
    chartInstance._setOptionTimer = setTimeout(() => {
      try {
        chartInstance.setOption(option, notMerge)
      } catch (error) {
        console.warn('设置图表选项失败，已屏蔽错误:', error.message)
        // 静默处理错误，不抛出异常
      }
    }, 100)
  } catch (error) {
    console.warn('图表设置过程中发生错误，已屏蔽:', error.message)
  }
}

/**
 * 验证ECharts配置
 * @param {Object} option - 图表配置
 * @returns {boolean} 配置是否有效
 */
export function validateChartOption(option) {
  if (!option || typeof option !== 'object') return false
  
  // 检查必要的配置项
  const hasSeries = option.series && Array.isArray(option.series) && option.series.length > 0
  const hasValidSeries = hasSeries && option.series.every(series => 
    series && typeof series === 'object' && series.type
  )
  
  return hasValidSeries
}

/**
 * 处理图表数据映射
 * @param {Array} data - 原始数据
 * @param {Object} mapping - 字段映射
 * @returns {Array} 映射后的数据
 */
export function mapChartData(data, mapping) {
  if (!isValidArray(data)) return []
  
  return data.map(item => {
    const mappedItem = {}
    Object.keys(mapping).forEach(key => {
      const sourceField = mapping[key]
      mappedItem[key] = item[sourceField] || 0
    })
    return mappedItem
  })
}

/**
 * 创建渐变色配置
 * @param {Array} colors - 颜色数组
 * @returns {Object} 渐变色配置
 */
export function createGradientColor(colors) {
  if (!Array.isArray(colors) || colors.length < 2) {
    colors = ['#83bff6', '#188df0']
  }
  
  return new echarts.graphic.LinearGradient(0, 0, 0, 1, 
    colors.map((color, index) => ({
      offset: index / (colors.length - 1),
      color: color
    }))
  )
}
